package com.ruoyi.ucar.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DictUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.ucar.boreq.BrandPriceDetailQueryBoReq;
import com.ruoyi.ucar.boreq.BrandPriceListQueryBoReq;
import com.ruoyi.ucar.boresp.*;
import com.ruoyi.ucar.domain.TBrandPrice;
import com.ruoyi.ucar.domain.po.BrandPriceDetailPo;
import com.ruoyi.ucar.domain.po.BrandPriceListPo;
import com.ruoyi.ucar.mapper.TBrandPriceMapper;
import com.ruoyi.ucar.moreq.BrandPriceDetailQueryMoReq;
import com.ruoyi.ucar.moreq.BrandPriceListQueryMoReq;
import com.ruoyi.ucar.service.ITBrandPriceService;
import com.ruoyi.ucar.util.CommonUtil;
import com.ruoyi.ucar.voreq.BrandPriceAddVoReq;
import com.ruoyi.ucar.voreq.BrandPriceUpdateVoReq;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.AllArgsConstructor;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;


/**
 * 车辆品牌价格Service业务层处理
 *
 * @author ruoyi
 * @date 2025-07-02
 */
@Service
@AllArgsConstructor
public class TBrandPriceServiceImpl extends ServiceImpl<TBrandPriceMapper, TBrandPrice> implements ITBrandPriceService
{
    private final TBrandPriceMapper tBrandPriceMapper;
    @Autowired
    private RedisCache redisCache;
    @PostConstruct
    public void init()
    {
        loadingBrandPriceCache();
    }

    @Override
    public void loadingBrandPriceCache()
    {
        List<TBrandPrice>  brandPriceList = this.tBrandPriceMapper.selectList(new LambdaQueryWrapper<TBrandPrice>().eq(TBrandPrice::getDeleteFlag,1l));
        Map<String, List<TBrandPrice>> groupedByProductType = brandPriceList.stream()
                .collect(Collectors.groupingBy(TBrandPrice::getProductType));
        Set<Map.Entry<String, List<TBrandPrice>>>   entrySet=groupedByProductType.entrySet();

        for(Map.Entry<String, List<TBrandPrice>> entry:entrySet){
            redisCache.setCacheObject(CacheConstants.BRAND_PRICE_KEY+entry.getKey(), entry.getValue());
        }
    }


    @Override
    public void  updateBrandPriceCache(String productType){
        redisCache.deleteObject(CacheConstants.BRAND_PRICE_KEY+productType);
        List<TBrandPrice>  brandPriceList = this.tBrandPriceMapper.selectList(new LambdaQueryWrapper<TBrandPrice>().eq(TBrandPrice::getDeleteFlag,1l).eq(TBrandPrice::getProductType,productType));
        redisCache.setCacheObject(CacheConstants.BRAND_PRICE_KEY+productType, brandPriceList);
    }



    @Override
    public String importBrandPrice(List<TBrandPrice> brandPriceList, Boolean isUpdateSupport, String operName) {
        if (StringUtils.isNull(brandPriceList) || brandPriceList.size() == 0)
        {
            throw new ServiceException("导入品牌价格数据不能为空！");
        }
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        for (TBrandPrice tBrandPrice : brandPriceList)
        {
            try
            {

            }
            catch (Exception e)
            {

            }
        }
        if (failureNum > 0)
        {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        }
        else
        {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        return successMsg.toString();
    }

    /**
     * 查询车辆品牌价格
     * @param id 车辆品牌价格主键
     * @return 车辆品牌价格
     */
    @Override
    public TBrandPrice selectTBrandPriceById(Long id)
    {
        return tBrandPriceMapper.selectTBrandPriceById(id);
    }

    /**
     * 查询车辆品牌价格列表
     * @param tBrandPrice 车辆品牌价格
     * @return 车辆品牌价格
     */
    @Override
    public List<TBrandPrice> selectTBrandPriceList(TBrandPrice tBrandPrice)
    {
        return tBrandPriceMapper.selectTBrandPriceList(tBrandPrice);
    }

    /**
     * 新增车辆品牌价格
     * @param tBrandPrice 车辆品牌价格
     * @return 结果
     */
@Override
    public int insertTBrandPrice(TBrandPrice tBrandPrice)
    {
    return tBrandPriceMapper.insert(tBrandPrice);

    }

    /**
     * 修改车辆品牌价格
     * @param tBrandPrice 车辆品牌价格
     * @return 结果
     */
@Override
    public int updateTBrandPrice(TBrandPrice tBrandPrice)
    {
    return tBrandPriceMapper.updateById(tBrandPrice);
    }

    /**
     * 批量删除车辆品牌价格
     * @param ids 需要删除的车辆品牌价格主键
     * @return 结果
     */
    @Override
    public int deleteTBrandPriceByIds(Long[] ids)
    {
        return tBrandPriceMapper.deleteTBrandPriceByIds(ids);
    }

    /**
     * 删除车辆品牌价格信息
     * @param id 车辆品牌价格主键
     * @return 结果
     */
    @Override
    public int deleteTBrandPriceById(Long id)
    {
        return tBrandPriceMapper.deleteTBrandPriceById(id);
    }



    @Override
    public String saveTBrandPrice(BrandPriceAddVoReq brandPriceAddVoReq) {
        TBrandPrice tBrandPrice= CommonUtil.objToObj(brandPriceAddVoReq,TBrandPrice.class);
        String brandPriceUuid=CommonUtil.createUuid();
        tBrandPrice.setBrandPriceUuid(brandPriceUuid);
        tBrandPrice.setDeleteFlag(1L);
        tBrandPrice.setCreatedBy(SecurityUtils.getUsername());
        tBrandPriceMapper.insert(tBrandPrice);
        return brandPriceUuid;
    }

    @Override
    public Long judgeTBrandPrice(String vehicleBrand, String productType) {
        return tBrandPriceMapper.selectCount(new LambdaQueryWrapper<TBrandPrice>().eq(TBrandPrice::getProductType,productType).eq(TBrandPrice::getVehicleBrand,vehicleBrand).eq(TBrandPrice::getDeleteFlag,1l));
    }

    @Override
    public int updateTBrandPrice(BrandPriceUpdateVoReq brandPriceUpdateVoReq) {
        TBrandPrice tBrandPrice= this.selectTBrandPriceByBrandPriceUuid(brandPriceUpdateVoReq.getBrandPriceUuid());
        tBrandPrice.setPrice(brandPriceUpdateVoReq.getPrice());
        tBrandPrice.setProductType(brandPriceUpdateVoReq.getProductType());
        tBrandPrice.setPurchasingPrice(brandPriceUpdateVoReq.getPurchasingPrice());
        tBrandPrice.setRealPrice(brandPriceUpdateVoReq.getRealPrice());
        tBrandPrice.setReturnPrice(brandPriceUpdateVoReq.getReturnPrice());
        tBrandPrice.setVehicleBrand(brandPriceUpdateVoReq.getVehicleBrand());
        tBrandPrice.setDeleteFlag(1L);
        tBrandPrice.setUpdatedBy(SecurityUtils.getUsername());
        return tBrandPriceMapper.update(tBrandPrice,new LambdaQueryWrapper<TBrandPrice>().eq(TBrandPrice::getBrandPriceUuid,brandPriceUpdateVoReq.getBrandPriceUuid()).eq(TBrandPrice::getDeleteFlag,1l));
    }

    @Override
    public TBrandPrice selectTBrandPriceByBrandPriceUuid(String brandPriceUuid) {
        return this.tBrandPriceMapper.selectOne(new LambdaQueryWrapper<TBrandPrice>().eq(TBrandPrice::getBrandPriceUuid,brandPriceUuid).eq(TBrandPrice::getDeleteFlag,1l));
    }

    @Override
    public int deleteTBrandPriceById(String brandPriceUuid, Long id) {
        TBrandPrice tBrandPrice=null;
        if(StringUtils.isNotEmpty(brandPriceUuid)) {
            tBrandPrice = this.selectTBrandPriceByBrandPriceUuid(brandPriceUuid);
            tBrandPrice.setDeleteFlag(-1l);
            tBrandPrice.setUpdatedBy(SecurityUtils.getUsername());
            int deleteNumber=tBrandPriceMapper.update(tBrandPrice,new LambdaQueryWrapper<TBrandPrice>().eq(TBrandPrice::getBrandPriceUuid, brandPriceUuid));
            this.updateBrandPriceCache(tBrandPrice.getProductType());
            return deleteNumber;
        }else{
            tBrandPrice = this.getById(id);
            tBrandPrice.setDeleteFlag(-1l);
            tBrandPrice.setUpdatedBy(SecurityUtils.getUsername());
            int deleteNumber= tBrandPriceMapper.update(tBrandPrice,new LambdaQueryWrapper<TBrandPrice>().eq(TBrandPrice::getId, id));
            this.updateBrandPriceCache(tBrandPrice.getProductType());
            return deleteNumber;
        }
    }

    @Override
    public BrandPriceDetailBoResq brandPriceDetailQuery(BrandPriceDetailQueryBoReq brandPriceDetailQueryBoReq) {
        BrandPriceDetailQueryMoReq brandPriceDetailQueryMoReq=CommonUtil.objToObj(brandPriceDetailQueryBoReq, BrandPriceDetailQueryMoReq.class)  ;
        brandPriceDetailQueryMoReq.setDeleteFlag(1l);
        List<BrandPriceDetailPo> brandPriceDetailPoList=tBrandPriceMapper.brandPriceDetailQuery(brandPriceDetailQueryMoReq);
        if(StringUtils.isNotNull(brandPriceDetailPoList)&&brandPriceDetailPoList.size()>0){
            BrandPriceDetailPo brandPriceDetailPo=brandPriceDetailPoList.get(0);
            BrandPriceDetailBoResq brandPriceDetailBoResq=CommonUtil.objToObj(brandPriceDetailPo,BrandPriceDetailBoResq.class);
            brandPriceDetailBoResq.setProductTypeDict(DictUtils.getDictLabel("product_type",brandPriceDetailPo.getProductType()));
            return brandPriceDetailBoResq;
        }else{
            return null;
        }
    }
    protected final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public BrandPriceListBoResp brandPriceListQueryPage(BrandPriceListQueryBoReq brandPriceListQueryBoReq) {
        BrandPriceListBoResp brandPriceListBoResp = new BrandPriceListBoResp();
        Page<BrandPriceListPo> page=new Page<>(brandPriceListQueryBoReq.getPageIndex(),brandPriceListQueryBoReq.getPageSize());
        BrandPriceListQueryMoReq brandPriceListQueryMoReq=CommonUtil.objToObj(brandPriceListQueryBoReq, BrandPriceListQueryMoReq.class);
        brandPriceListQueryMoReq.setDeleteFlag(1l);
        IPage<BrandPriceListPo> brandPriceListQueryPage= tBrandPriceMapper.brandPriceListQueryPage(page,brandPriceListQueryMoReq);
        if(StringUtils.isNotNull(brandPriceListQueryPage.getRecords())&&brandPriceListQueryPage.getRecords().size()>0){
            brandPriceListBoResp.setTotalCount(new Integer(String.valueOf(brandPriceListQueryPage.getTotal())));
            brandPriceListBoResp.setTotalPage(new Integer(String.valueOf(brandPriceListQueryPage.getPages())));
            List<BrandPriceListBo>  brandPriceListBos=new ArrayList<>();
            brandPriceListQueryPage.getRecords().forEach(brandPriceListPo -> {
                BrandPriceListBo brandPriceListBo=CommonUtil.objToObj(brandPriceListPo,BrandPriceListBo.class);
                brandPriceListBo.setProductTypeDict(DictUtils.getDictLabel("product_type",brandPriceListPo.getProductType()));
                brandPriceListBos.add(brandPriceListBo);
            });
            brandPriceListBoResp.setBrandPriceListBos(brandPriceListBos);
            logger.info("车辆品牌价格查询BO端返回结果：{}"+brandPriceListBoResp);
        }else{
            return null;
        }
        return brandPriceListBoResp;
    }

}
